home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / apps / xconf / ConfDoc.c++ next >
C/C++ Source or Header  |  1994-08-01  |  27KB  |  958 lines
  1. /*
  2.  * Copyright 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17.  
  18. // Conf includefile
  19. #include "ConfDoc.h"
  20.  
  21. // unix includes
  22. #include <stdlib.h>
  23. #include <sys/socket.h>
  24. #include <malloc.h>
  25. #include <ctype.h>
  26. #include <fcntl.h>
  27. #include <unistd.h>
  28. #include <bstring.h>
  29. #include <CC/osfcn.h>
  30. #include <netdb.h>
  31. #include <arpa/inet.h>
  32.  
  33. // X11 and motif includes
  34. #include <X11/StringDefs.h>
  35. #include <Xm/Text.h>
  36. #include <Xm/PushB.h>
  37. #include <Xm/Separator.h>
  38. #include <Xm/Form.h>
  39. #include <Xm/Frame.h>
  40. #include <Xm/Label.h>
  41.  
  42. ///////////////////////////////////////////////////////////////////////////////
  43. //    callback definitions
  44. ///////////////////////////////////////////////////////////////////////////////
  45.  
  46. void ConfDoc::quitCB(Widget, XtPointer clientData, XtPointer)
  47. {
  48.    ConfDoc *obj = (ConfDoc *)clientData;
  49.  
  50.    obj->sendMsg(LOGOUT, obj->_user, obj->_group, " ");
  51.    close(obj->_socket);
  52.    exit(1);
  53. }
  54.  
  55.  
  56. void ConfDoc::usersCB(Widget, XtPointer clientData, XtPointer)
  57. {
  58.    ConfDoc *obj = (ConfDoc *)clientData;
  59.  
  60.    obj->_userList.open();
  61. }
  62.  
  63.  
  64. void ConfDoc::groupsCB(Widget, XtPointer clientData, XtPointer)
  65. {
  66.    ConfDoc *obj = (ConfDoc *)clientData;
  67.  
  68.    obj->_groupList.open();
  69. }
  70.  
  71.  
  72. void ConfDoc::helpCB(Widget, XtPointer clientData, XtPointer)
  73. {
  74.    ConfDoc *obj = (ConfDoc *)clientData;
  75.  
  76.    obj->_helpList.open();
  77. }
  78.  
  79.  
  80. void ConfDoc::recvCB(XtPointer data, int /*sock*/, XtInputId* /*id*/)
  81. {
  82.    ConfDoc *obj = (ConfDoc *)data;
  83.    struct Message msg, reply;
  84.    struct sockaddr_in f;
  85.    int fromlen = sizeof(f);
  86.    char buf[MAX_BUF_SIZE];
  87.    char tbuf[16];
  88.    time_t rawtime;
  89.  
  90.    if(recvfrom(obj->_socket, &msg, sizeof(msg),0, &f, &fromlen) < 0) {
  91.       if(errno == EBADF)
  92.          exit(-1);
  93.       perror("recvfrom");
  94.       exit(-1);
  95.    }
  96.  
  97.    // if it's an unknown group, add it to the list
  98.    if(!obj->_groupList.find(msg.group)) {
  99.       obj->_groupList.add(msg.group);
  100.       bzero(msg.data, sizeof(msg.data));  // clear send buffer
  101.       return;
  102.    }
  103.  
  104.    // if it's a broadcast message, print it and return
  105.    if(msg.flags == BROADCAST) {
  106.       time(&rawtime);
  107.       cftime(tbuf, "%I:%M ", &rawtime);
  108.       strcpy(buf, "BCAST> ");
  109.       strcat(buf, tbuf);
  110.       strcat(buf, msg.data);
  111.       obj->_recvConfText->putStr(buf);
  112.       bzero(msg.data, sizeof(msg.data));  // clear send buffer
  113.       return;
  114.    }
  115.  
  116.    // if it's for our group
  117.    if(obj->_groupList.findSelected(msg.group)) {
  118.       // add any unknown users
  119.       if(!obj->_userList.find(msg.user)) {
  120.          obj->_userList.add(msg.user);
  121.       }
  122.       // check the msg type, and do the right thing
  123.       switch(msg.flags) {
  124.          case MESSAGE :
  125.             time(&rawtime);
  126.             cftime(tbuf, "%I:%M ", &rawtime);
  127.             strcpy(buf, tbuf);
  128.             strcat(buf, msg.data);
  129.             obj->_recvConfText->putStr(buf);
  130.             break;
  131.          case USER :
  132.             // announce the name change
  133.             strcpy(buf, "NAME> '");
  134.             strcat(buf, msg.data);
  135.             strcat(buf, "' changed to '");
  136.             strcat(buf, msg.user);
  137.             strcat(buf, "'.");
  138.             obj->_recvConfText->putStr(buf);
  139.             // remove the old name from the user list
  140.             obj->_userList.remove(msg.data);
  141.             // if it's you, change yer name
  142.             if(!strcmp(msg.data, obj->_user))
  143.                strcpy(obj->_user, msg.user);
  144.             break;
  145.          case PRIVATE :
  146.             if(!strcmp(msg.user, obj->_user)) {
  147.                strcpy(buf, "PRIVATE> ");
  148.                strcat(buf, msg.data);
  149.                obj->_recvConfText->putStr(buf);
  150.             }
  151.             break;
  152.          case LOGIN :
  153.             // announce the new user
  154.             strcpy(buf, "LOGIN> ");
  155.             strcat(buf, msg.user);
  156.             obj->_recvConfText->putStr(buf);
  157.             // send a reply
  158.             f.sin_port = obj->_port;
  159.             reply.flags = REPLY;
  160.             strcpy(reply.user, obj->_user);
  161.             strcpy(reply.group, obj->_group);
  162.             sendto(obj->_socket, &reply, sizeof(reply), 0, &f, sizeof(f));
  163.             break;
  164.          case FIND :
  165.             // send a reply
  166.             f.sin_port = obj->_port;
  167.             reply.flags = REPLY;
  168.             strcpy(reply.user, obj->_user);
  169.             strcpy(reply.group, obj->_group);
  170.             sendto(obj->_socket, &reply, sizeof(reply), 0, &f, sizeof(f));
  171.             break;
  172.          case LOGOUT :
  173.             // announce the user's exit
  174.             strcpy(buf, "LOGOUT> ");
  175.             strcat(buf, msg.user);
  176.             obj->_recvConfText->putStr(buf);
  177.             // remove user from the user list
  178.             obj->_userList.remove(msg.user);
  179.             break;
  180.          case RING :
  181.             if(!strcmp(msg.user, obj->_user)) {
  182.                XBell(XtDisplay(obj->_recvText), 50);
  183.                strcpy(buf, "RING> ");
  184.                strcat(buf, msg.data);
  185.                obj->_recvConfText->putStr(buf);
  186.             }
  187.             break;
  188.          case URGENT :
  189.             strcpy(buf, "URGENT> ");
  190.             strcat(buf, msg.data);
  191.             obj->_recvConfText->putStr(buf, TRUE);
  192.             break;
  193.          case REPLY :
  194.             break;
  195.          default :
  196.             break;
  197.       }
  198.    }
  199.  
  200.    // clear the msg buffer
  201.    bzero(msg.data, sizeof(msg.data));  // clear send buffer
  202. }
  203.  
  204.  
  205. void ConfDoc::sendCB(Widget, XtPointer clientData, XtPointer callData)
  206. {
  207.    char buf[MAX_BUF_SIZE];
  208.    ConfDoc *obj = (ConfDoc *)clientData;
  209.    XmAnyCallbackStruct *data = (XmAnyCallbackStruct *)callData;
  210.  
  211.    char *tmp = XmTextGetString(obj->_sendText);
  212.  
  213.    if(strlen(tmp) > MAX_BUF_SIZE) {
  214.       obj->_recvConfText->putStr("ERROR> input too long (255 chars max).");
  215.       XtFree(tmp);
  216.       return;
  217.    }
  218.  
  219.    strcpy(buf, tmp);
  220.    XtFree(tmp);
  221.  
  222.    if(buf[0] == ':') {
  223.       switch (tolower(buf[1])) {
  224.          case 'b' :
  225.             obj->sendBroadcast(buf);
  226.             break;
  227.          case 'c' :
  228.             // obj->setupChannel(buf);
  229.             obj->_recvConfText->putStr("INFO> 'channel' not implemented.");
  230.             break;
  231.          case 'f' :
  232.             obj->_recvConfText->putStr("INFO> performing find.");
  233.             obj->findUser(buf);
  234.             break;
  235.          case 'g' :
  236.             obj->setGroup(buf);
  237.             break;
  238.          case 'h' :
  239.          case '?' :
  240.             obj->_helpList.open();
  241.             break;
  242.          case 'n' :
  243.             obj->setName(buf);
  244.             break;
  245.          case 'q' :
  246.             // make this think we're x doing a callback
  247.             obj->quitCB(NULL, (XtPointer)obj, NULL);
  248.          case 'p' :
  249.          case 's' :
  250.             obj->sendPrivate(buf, 0);
  251.             break;
  252.          case 'r' :
  253.             obj->sendPrivate(buf, 1);
  254.             break;
  255.          case 'u' :
  256.             obj->sendUrgent(buf);
  257.             break;
  258.          case 'v' :
  259.             obj->_recvConfText->putStr("INFO> xconf version 2.08");
  260.             break;
  261.          case 'w' :
  262.             obj->_userList.open();
  263.             break;
  264.          default :
  265.             obj->_recvConfText->putStr("ERROR> No such command.");
  266.             break;
  267.       }
  268.    }
  269.    else {
  270.       obj->sendMsg(MESSAGE, obj->_user, obj->_group, buf);
  271.    }
  272.    bzero(buf, MAX_BUF_SIZE);
  273.   
  274.    // reset for the next message
  275.    XmTextSetString(obj->_sendText, "");
  276.    XmTextSetInsertionPosition(obj->_sendText, 0);
  277. }
  278.  
  279. ///////////////////////////////////////////////////////////////////////////////
  280. //    end of callback definitions
  281. ///////////////////////////////////////////////////////////////////////////////
  282.  
  283. ConfDoc::ConfDoc(XtAppContext app, const char*)
  284. {
  285.    _app = app;
  286. }
  287.  
  288.  
  289. ConfDoc::~ConfDoc() {}
  290.  
  291.  
  292. void ConfDoc::init(int port, char* server)
  293. {  
  294.    _port = port;
  295.    _server = server;
  296.  
  297.    _user = (char *)malloc(30*sizeof(char));  // reserve 30 bytes for 'user'
  298.    _group = (char *)malloc(30*sizeof(char));  // reserve 30 bytes for 'group'
  299.  
  300.    // JR - working on the .xconfrc stuff..
  301.    // open the .confrc file
  302.    // _rcfile.open();
  303.    // _rcfile.read();
  304.  
  305.    if(!(_user = getenv("CONFUSER"))) {
  306.       if(!(_user = getenv("LOGNAME"))) {
  307.          _user = "def_user";
  308.       }
  309.    }
  310.    if(!(_group = getenv("CONFGROUP"))) {
  311.       _group = "def_group";
  312.    }
  313.    _userList.add(_user);
  314.    _groupList.add(_group, TRUE);
  315.    setInputLabel(_group);
  316.  
  317.    // load the help information
  318.    _helpList.add("Commands start with a colon (:) Available commands are:");
  319.    _helpList.add("( [] denotes optional characters/fields)");
  320.    _helpList.add("  :b[roadcast] msg ---- broadcast a message to all groups.");
  321.    _helpList.add("  :c[hannel] user ----- open a private channel to 'user'.");
  322.    _helpList.add("  :f[ind] user -------- report whether 'user' is logged in.");
  323.    _helpList.add("  :g[roup] group ------ change your group to 'group'.");
  324.    _helpList.add("  :h[elp] ------------- print this help message.");
  325.    _helpList.add("  :n[ame] name -------- change your name to 'name'.");
  326.    _helpList.add("  :q[uit] ------------- quit this program.");
  327.    _helpList.add("  :r[ing] user [msg] -- ring the bell of 'user'");
  328.    _helpList.add("  :s[end] user msg ---- send a private message to 'user'.");
  329.    _helpList.add("  :u[rgent] msg ------- send an urgent message.");
  330.    _helpList.add("  :v[ersion] ---------- show xconf version number.");
  331.    _helpList.add("  :w[ho] -------------- bring up the user dialog.");
  332.    _helpList.add(" ");
  333.  
  334.    if(!setupSockets()) {
  335.       exit(-1);
  336.    }
  337.  
  338.    // announce that you're here
  339.    if(!sendMsg(LOGIN, _user, _group, " "))
  340.       _recvConfText->putStr("ERROR> sendMsg() failed.");
  341. }
  342.  
  343.  
  344. Boolean ConfDoc::setupSockets()
  345. {
  346.    _addrSize = sizeof(struct sockaddr_in);
  347.  
  348.    bzero(&_sendAddr, _addrSize);
  349.    _sendAddr.sin_family = AF_INET;
  350.    _sendAddr.sin_port = htons(_port);
  351.    _sendAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  352.  
  353.    bzero(&_recvAddr, _addrSize);
  354.    _recvAddr.sin_family = AF_INET;
  355.    _recvAddr.sin_port = htons(_port);
  356.    _recvAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  357.  
  358.    if(_server) {
  359.       if(!setupTCP()) {
  360.          fprintf(stderr, "Error setting up connection to %s.\n", _server);
  361.          return(FALSE);
  362.       }
  363.    }
  364.    else {
  365.       if(!setupUDP()) {
  366.          fprintf(stderr, "Error setting up multicast socket.\n");
  367.          return(FALSE);
  368.       }
  369.    }
  370.  
  371.    // add the receiving socket as an input source
  372.    XtAppAddInput(_app, _socket, (XtPointer)XtInputReadMask,
  373.                 (XtInputCallbackProc)&ConfDoc::recvCB, (XtPointer)this);
  374.  
  375.    return(TRUE);
  376. }
  377.  
  378.  
  379. Boolean ConfDoc::setupTCP()
  380. {
  381.    // bind to a remote machine
  382.    _socket = socket(AF_INET, SOCK_STREAM, 0);
  383.    if(_socket < 0) {
  384.       perror("socket");
  385.       return(FALSE);
  386.    }
  387.  
  388.    struct hostent *hp = gethostbyname(_server);
  389.    if (hp == NULL) {
  390.       perror("gethostbyname");
  391.       return(FALSE);
  392.    }
  393.    memcpy(&_sendAddr.sin_addr, hp->h_addr, hp->h_length);
  394.  
  395.    if(connect(_socket, &_sendAddr, _addrSize) < 0) {
  396.       perror("connect");
  397.       return(FALSE);
  398.    }
  399.  
  400.    return(TRUE);
  401. }
  402.  
  403.  
  404. Boolean ConfDoc::setupUDP()
  405. {
  406.    _socket = socket(AF_INET, SOCK_DGRAM, 0);
  407.    if(_socket < 0) {
  408.       perror("socket");
  409.       return(FALSE);
  410.    }
  411.  
  412.    int on = 1;
  413.    // doing this before the bind allows multiple bindings to this port
  414.    if(setsockopt(_socket, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)) < 0) {
  415.       perror("setsockopt(SO_REUSEPORT)");
  416.       return(FALSE);
  417.    }
  418.  
  419.    // bind to a multicast address
  420.    struct in_addr grpAddr;
  421.    grpAddr.s_addr = inet_addr(XCONF_MCAST_GROUP);
  422.    if(!IN_MULTICAST(grpAddr.s_addr)) {
  423.       fprintf(stderr, "Invalid multicast group address.\n");
  424.       return(FALSE);
  425.    }
  426.  
  427.    u_char ttl = MAX_MCAST_HOPS;
  428.    int sz = sizeof(ttl);
  429.    if(setsockopt(_socket, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sz) < 0) {
  430.       perror("setsockopt(IP_MULTICAST_TTL)");
  431.       return(FALSE);
  432.    }
  433.    _sendAddr.sin_addr = grpAddr;
  434.  
  435.    struct ip_mreq mreq;
  436.    mreq.imr_multiaddr = grpAddr;
  437.    struct in_addr ifAddr;
  438.    ifAddr.s_addr = htonl(INADDR_ANY);
  439.    mreq.imr_interface = ifAddr;
  440.    sz = sizeof(mreq);
  441.    if(setsockopt(_socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sz) < 0) {
  442.       perror("setsockopt(IP_ADD_MEMBERSHIP)");
  443.       return(FALSE);
  444.    }
  445.  
  446.    if(bind(_socket, &_recvAddr, _addrSize) < 0) {
  447.       perror("bind");
  448.       return(FALSE);
  449.    }
  450.  
  451.    if(fcntl(_socket, F_SETFL, FASYNC) < 0) {
  452.       perror("fcntl");
  453.       return(FALSE);
  454.    }
  455.    if(fcntl(_socket, F_SETOWN, getpid()) < 0) {
  456.       perror("fcntl");
  457.       return(FALSE);
  458.    }
  459.  
  460.    return(TRUE);
  461. }
  462.  
  463.  
  464. Widget ConfDoc::build(Widget parent)
  465. {
  466.    Arg args[10];  // make sure this is large enough
  467.  
  468.    // create the main form that all the subcomponents will go in
  469.    Widget form = XmCreateForm(parent, "form", NULL, 0);
  470.    XtManageChild(form);
  471.  
  472.    // create the output label
  473.    int n = 0;
  474.    XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM);  n++;
  475.    XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);  n++;
  476.    Widget outputLabel = XmCreateLabel(form, "outputLabel", args, n);
  477.    XtManageChild(outputLabel);
  478.  
  479.    // create a help button
  480.    n = 0;
  481.    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);  n++;
  482.    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM);  n++;
  483.    Widget helpButton = XmCreatePushButton(form, "helpButton", args, n);
  484.    XtManageChild(helpButton);
  485.    XtAddCallback(helpButton, XmNactivateCallback,
  486.             (XtCallbackProc)&ConfDoc::helpCB, (XtPointer)this);
  487.  
  488.    // create a groups button
  489.    n = 0;
  490.    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM);  n++;
  491.    XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET);  n++;
  492.    XtSetArg(args[n], XmNrightWidget, helpButton);  n++;
  493.    Widget usersButton = XmCreatePushButton(form, "usersButton", args, n);
  494.    XtManageChild(usersButton);
  495.    XtAddCallback(usersButton, XmNactivateCallback,
  496.             (XtCallbackProc)&ConfDoc::usersCB, (XtPointer)this);
  497.  
  498.    // create a users button
  499.    n = 0;
  500.    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM);  n++;
  501.    XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET);  n++;
  502.    XtSetArg(args[n], XmNrightWidget, usersButton);  n++;
  503.    Widget groupsButton = XmCreatePushButton(form, "groupsButton", args, n);
  504.    XtManageChild(groupsButton);
  505.    XtAddCallback(groupsButton, XmNactivateCallback,
  506.             (XtCallbackProc)&ConfDoc::groupsCB, (XtPointer)this);
  507.  
  508.    // create a quit button
  509.    n = 0;
  510.    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM);  n++;
  511.    XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET);  n++;
  512.    XtSetArg(args[n], XmNrightWidget, groupsButton);  n++;
  513.    Widget quitButton = XmCreatePushButton(form, "quitButton", args, n);
  514.    XtManageChild(quitButton);
  515.    XtAddCallback(quitButton, XmNactivateCallback,
  516.             (XtCallbackProc)&ConfDoc::quitCB, (XtPointer)this);
  517.  
  518.    // create a separator between the input and command areas
  519.    n = 0;
  520.    XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);  n++;
  521.    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);  n++;
  522.    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET);  n++;
  523.    XtSetArg(args[n], XmNbottomWidget, quitButton);  n++;
  524.    Widget separator = XmCreateSeparator(form, "separator", args, n);
  525.    XtManageChild(separator);
  526.  
  527.    // create a frame for the text input area
  528.    n = 0;
  529.    XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);  n++;
  530.    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);  n++;
  531.    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET);  n++;
  532.    XtSetArg(args[n], XmNbottomWidget, separator);  n++;
  533.    Widget sendFrame = XmCreateFrame(form, "sendFrame", args, n);
  534.    XtManageChild(sendFrame);
  535.  
  536.    // create a text input area
  537.    n = 0;
  538.    XtSetArg(args[n], XmNorientation, XmHORIZONTAL);  n++;
  539.    Widget sendForm = XmCreateForm(sendFrame, "sendForm", args, n);
  540.    XtManageChild(sendForm);
  541.  
  542.    // create the text input prompt
  543.    n = 0;
  544.    XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM);  n++;
  545.    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM);  n++;
  546.    XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);  n++;
  547.    Widget sendPrompt = XmCreateText(sendForm, "sendPrompt", args, n);
  548.    XtManageChild(sendPrompt);
  549.    XmTextSetString(sendPrompt, "msg>");
  550.  
  551.    // create the text input field
  552.    n = 0;
  553.    XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM);  n++;
  554.    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM);  n++;
  555.    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);  n++;
  556.    XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET);  n++;
  557.    XtSetArg(args[n], XmNleftWidget, sendPrompt);  n++;
  558.    _sendText = XmCreateText(sendForm, "sendText", args, n);
  559.    XtManageChild(_sendText);
  560.    XtAddCallback(_sendText, XmNactivateCallback,
  561.             (XtCallbackProc)&ConfDoc::sendCB, (XtPointer)this);
  562.  
  563.    // create the input label
  564.    n = 0;
  565.    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET);  n++;
  566.    XtSetArg(args[n], XmNbottomWidget, sendFrame);  n++;
  567.    XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);  n++;
  568.    _inputLabel = XmCreateLabel(form, "inputLabel", args, n);
  569.    XtManageChild(_inputLabel);
  570.  
  571.    // create the text output field
  572.    n = 0;
  573.    XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT);  n++;
  574.    XtSetArg(args[n], XmNeditable, False);  n++;
  575.    XtSetArg(args[n], XmNcursorPositionVisible, False);  n++;
  576.    XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET);  n++;
  577.    XtSetArg(args[n], XmNtopWidget, outputLabel);  n++;
  578.    XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);  n++;
  579.    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);  n++;
  580.    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET);  n++;
  581.    XtSetArg(args[n], XmNbottomWidget, _inputLabel);  n++;
  582.    _recvText = XmCreateScrolledText(form, "recvText", args, n);
  583.    XtManageChild(_recvText);
  584.    _recvConfText = new ConfText(_recvText, NULL);
  585.  
  586.    // send all input from the keyboard to the text input field
  587.    XtSetKeyboardFocus(form, _sendText);
  588.  
  589.    // initialize the group, user and help dialogs
  590.    _groupList.init(parent, "groups");
  591.    _userList.init(parent, "users");
  592.    _helpList.init(parent, "help");
  593.  
  594.    return(form);
  595. }
  596.  
  597.  
  598. Boolean ConfDoc::setupChannel(char *buf)
  599. { 
  600.    // make sure a name was supplied
  601.    if(numWords(buf) == 1) {
  602.       _recvConfText->putStr("ERROR> No name supplied.");
  603.       return(FALSE);
  604.    }
  605.  
  606.    // make sure the name's not too long
  607.    char user[30];
  608.    char *tmp = (char *)getWord(buf, 2);
  609.    if(strlen(tmp) > 30) {
  610.       _recvConfText->putStr("ERROR> Maximum name length is 30 characters.");
  611.       return(FALSE);
  612.    }
  613.    strcpy(user, tmp);
  614.  
  615.    // check if user is logged in
  616.    if(!_userList.find(user)) {
  617.       char buf[MAX_BUF_SIZE];
  618.       strcpy(buf, "ERROR> user '");
  619.       strcat(buf, user);
  620.       strcat(buf, "' not logged in.");
  621.       _recvConfText->putStr(buf);
  622.       return(FALSE);
  623.    }
  624.  
  625.    PrivateList* plist = new PrivateList();
  626.    plist->init(_sendText, "private", user, this);
  627.    plist->open();
  628. }
  629.  
  630.  
  631. Boolean ConfDoc::findUser(char *buf)
  632. {
  633.    if(numWords(buf) == 1) {
  634.       _recvConfText->putStr("ERROR> No user name supplied.");
  635.       return(FALSE);
  636.    }
  637.  
  638.    char fuser[30];
  639.    char* tmp = (char*)getWord(buf, 2);
  640.    if(strlen(tmp) > 30) {
  641.       _recvConfText->putStr("ERROR> Invalid user name.");
  642.       return(FALSE);
  643.    }
  644.    strcpy(fuser, tmp);
  645.  
  646.    sendMsg(FIND, _user, _group, fuser);
  647.    sleep(1);
  648.  
  649.    char tbuf[MAX_BUF_SIZE];
  650.    strcpy(tbuf, "INFO> User '");
  651.    strcat(tbuf, fuser);
  652.    if(!_userList.find(fuser)) {
  653.       strcat(tbuf, "' not logged in.");
  654.       _recvConfText->putStr(tbuf);
  655.    }
  656.    else {
  657.       strcat(tbuf, "' logged in.");
  658.       _recvConfText->putStr(tbuf);
  659.    }
  660.    return(TRUE);
  661. }
  662.  
  663.  
  664. Boolean ConfDoc::setGroup(char *buf)
  665. {
  666.    if(numWords(buf) == 1) {
  667.       _groupList.open();
  668.       return(TRUE);
  669.    }
  670.  
  671.    if(numWords(buf) > 1) {
  672.       char new_group[30];
  673.       char* tmp = (char*)getWord(buf, 2);
  674.       if(strlen(tmp) > 30) {
  675.          _recvConfText->putStr("ERROR> Maximum name length is 30 characters.");
  676.          return(FALSE);
  677.       }
  678.       strcpy(new_group, tmp);
  679.       if(numWords(buf) == 2) {
  680.          // add this group to the list.
  681.          sendMsg(LOGOUT, _user, _group, " ");
  682.  
  683.          strcpy(_group, new_group);
  684.  
  685.          // if it's a new group, add it to the list.
  686.          if(!_groupList.find(new_group)) {
  687.             _groupList.add(new_group, TRUE);
  688.          } else {
  689.             _groupList.select(new_group);
  690.          }
  691.          _userList.clear();
  692.          setInputLabel(new_group);
  693.          sendMsg(LOGIN, _user, _group, " ");
  694.          return(TRUE);
  695.       }
  696.       // send a message to the given group.
  697.       char data[256];
  698.       char *word;
  699.       strcpy(data, "");  // initialize local buffer
  700.       int n = 3;
  701.       while((word = getWord(buf, n++)) != NULL) {
  702.          strcat(data, word);
  703.          strcat(data, " ");
  704.       }
  705.       sendMsg(MESSAGE, _user, new_group, data);
  706.    }
  707.    return(TRUE);
  708. }
  709.  
  710.  
  711. Boolean ConfDoc::setName(char *buf)
  712. {
  713.    if(numWords(buf) == 1) {
  714.       _recvConfText->putStr("ERROR> No name supplied.");
  715.       return(FALSE);
  716.    }
  717.  
  718.    char *tmp;
  719.    char new_user[30];
  720.    char old_user[30];
  721.  
  722.    tmp = (char *)getWord(buf, 2);
  723.    if(strlen(tmp) > 30) {
  724.       _recvConfText->putStr("ERROR> Maximum name length is 30 characters.");
  725.       return(FALSE);
  726.    }
  727.    strcpy(new_user, tmp);
  728.  
  729.    // check if already used
  730.    if(_userList.find(new_user) > 0) {
  731.       char buf[MAX_BUF_SIZE];
  732.       strcpy(buf, "ERROR> user '");
  733.       strcat(buf, new_user);
  734.       strcat(buf, "' already logged in.");
  735.       _recvConfText->putStr(buf);
  736.       return(FALSE);
  737.    }
  738.    strcpy(old_user, _user);
  739.  
  740.    strcpy(_user, new_user);
  741.  
  742.    // send message to all servers, printing out the change you've made
  743.    if(!sendMsg(USER, new_user, _group, old_user)) {
  744.       _recvConfText->putStr("ERROR> sendMsg() failed.");
  745.       return(FALSE);
  746.    }
  747.  
  748.    return(TRUE);
  749. }
  750.  
  751.  
  752. Boolean ConfDoc::sendMsg(short flags, char *user, char *group, char *data)
  753. {
  754.    struct Message msg;
  755.  
  756.    if(numWords(data) == 0) {
  757.       if(!((flags == LOGIN) || (flags == LOGOUT) || (flags == RING)))
  758.          return(FALSE);
  759.    }
  760.  
  761.    msg.flags = flags;
  762.    strcpy(msg.user, user);
  763.    strcpy(msg.group, group);
  764.    if(msg.flags == USER) {
  765.       strcpy(msg.data, data);
  766.    }
  767.    else {
  768.       strcpy(msg.data, "(");
  769.       strcat(msg.data, _user);
  770.       strcat(msg.data, ".");
  771.       strcat(msg.data, _group);
  772.       strcat(msg.data, "): ");
  773.       strcat(msg.data, data);
  774.    }
  775.  
  776.    int len = sizeof(msg) - sizeof(msg.data) + strlen(msg.data);
  777.  
  778.    if(sendto(_socket, &msg, sizeof(msg), 0, &_sendAddr, _addrSize) < 0) {
  779.       perror("send");
  780.       return(FALSE);
  781.    }
  782.    bzero(msg.data, sizeof(msg.data));  // clear send buffer
  783.    return(TRUE);
  784. }
  785.  
  786.  
  787. Boolean ConfDoc::sendBroadcast(char *buf)
  788. {
  789.    char *word;
  790.    char data[256];
  791.    int n = 2;
  792.  
  793.    if(numWords(buf) == 1) {
  794.       _recvConfText->putStr("ERROR> No message supplied.");
  795.       return(FALSE);
  796.    }
  797.  
  798.    strcpy(data, "");  // initialize local buffer
  799.    while((word = getWord(buf, n++)) != NULL) {
  800.       strcat(data, word);
  801.       strcat(data, " ");
  802.    }
  803.  
  804.    if(!sendMsg(BROADCAST, _user, _group, data)) {
  805.       _recvConfText->putStr("ERROR> sendMsg() failed.");
  806.       return(FALSE);
  807.    }
  808.    return(TRUE);
  809. }
  810.  
  811.  
  812. Boolean ConfDoc::sendPrivate(char *buf, int ring)
  813. {
  814.    int n = 3;
  815.    char user[30];
  816.    char data[256];
  817.    char *word;
  818.  
  819.    if(ring) {
  820.       if(numWords(buf) == 1) {
  821.          _recvConfText->putStr("ERROR> No user supplied.");
  822.          return(FALSE);
  823.       }
  824.    }
  825.    else {
  826.       if(numWords(buf) <= 2) {
  827.          _recvConfText->putStr("ERROR> No user or message supplied.");
  828.          return(FALSE);
  829.       }
  830.    }
  831.  
  832.    strcpy(user, getWord(buf, 2));
  833.  
  834.    // check if user is logged in
  835.    if(!_userList.find(user)) {
  836.       char buf[MAX_BUF_SIZE];
  837.       strcpy(buf, "ERROR> user '");
  838.       strcat(buf, user);
  839.       strcat(buf, "' not logged in.");
  840.       _recvConfText->putStr(buf);
  841.       return(FALSE);
  842.    }
  843.  
  844.    strcpy(data, "");  // initialize local buffer
  845.    while((word = getWord(buf, n++)) != NULL) {
  846.       strcat(data, word);
  847.       strcat(data, " ");
  848.    }
  849.  
  850.    // echo the text locally (to keep track of what you've typed
  851.    char tdata[256];
  852.    strcpy(tdata, "TO> (");
  853.    strcat(tdata, user);
  854.    strcat(tdata, "): ");
  855.    strcat(tdata, data);
  856.    _recvConfText->putStr(tdata);
  857.  
  858.    // this is a special case where we use the user field to represent
  859.    // the recipient, rather than the sender
  860.    if(ring) {
  861.       if(!sendMsg(RING, user, _group, data)) {
  862.          _recvConfText->putStr("ERROR> sendMsg() failed.");
  863.          return(FALSE);
  864.       }
  865.    }
  866.    else {
  867.       if(!sendMsg(PRIVATE, user, _group, data)) {
  868.          _recvConfText->putStr("ERROR> sendMsg() failed.");
  869.          return(FALSE);
  870.       }
  871.    }
  872.    return(TRUE);
  873. }
  874.  
  875.  
  876. Boolean ConfDoc::sendUrgent(char *buf)
  877. {
  878.    char *word;
  879.    char data[256];
  880.    int n = 2;
  881.  
  882.    if(numWords(buf) == 1) {
  883.       _recvConfText->putStr("ERROR> No message supplied.");
  884.       return(FALSE);
  885.    }
  886.  
  887.    bzero(data, sizeof(data));  // initialize local buffer
  888.    while((word = getWord(buf, n++)) != NULL) {
  889.       strcat(data, word);
  890.       strcat(data, " ");
  891.    }
  892.  
  893.    if(!sendMsg(URGENT, _user, _group, data)) {
  894.       _recvConfText->putStr("ERROR> sendMsg() failed.");
  895.       return(FALSE);
  896.    }
  897.    return(TRUE);
  898. }
  899.  
  900.  
  901. void ConfDoc::setInputLabel(char* label)
  902. {
  903.    char labelText[64];
  904.    strcpy(labelText, "Input: (group=");
  905.    strcat(labelText, label);
  906.    strcat(labelText, ")");
  907.    XmString labelString = XmStringCreate(labelText, XmSTRING_DEFAULT_CHARSET);
  908.    Arg args[1];
  909.    XtSetArg(args[0], XmNlabelString, labelString);
  910.    XtSetValues(_inputLabel, args, 1);
  911. }
  912.  
  913.  
  914. int ConfDoc::numWords(char *buf)
  915. {
  916.    int count = 0;
  917.    int end = 0;
  918.  
  919.    while(!end) {
  920.       while(*buf == ' ') buf++;
  921.       if(*buf == '\0') return(count);
  922.       count++;
  923.       while(*buf != ' ') {
  924.          if(*buf == '\0') return(count);
  925.          buf++;
  926.       }
  927.    }
  928. }
  929.  
  930.  
  931. char *ConfDoc::getWord(char *buf, int pos)
  932. {
  933.    static char word[256];
  934.    int n = 0;
  935.    int curpos = 0;
  936.  
  937.    if(numWords(buf) < pos) return(NULL);
  938.  
  939.    while(pos != curpos) {
  940.       while(*buf == ' ') buf++;
  941.       curpos++;
  942.  
  943.       if(*buf == '\0') return(NULL);
  944.  
  945.       while(*buf != ' ') {
  946.          if(*buf == '\0') {
  947.             curpos = pos;
  948.             break;
  949.          }
  950.          word[n++] = *buf++;
  951.       }
  952.       word[n] = '\0';
  953.       n = 0;
  954.    }
  955.    return(word);
  956. }
  957.  
  958.